package com.medical.standard.service;

import com.medicalstandard.dao.InspectionDAO;
import com.medicalstandard.dao.StandardDAO;
import com.medicalstandard.dao.TermDAO;
import com.medicalstandard.dao.DocumentTemplateDAO;
import com.medicalstandard.entity.Inspection;
import com.medicalstandard.entity.Standard;
import com.medicalstandard.entity.Term;
import com.medicalstandard.entity.DocumentTemplate;

import java.util.List;

public class DataInputService {
    private StandardDAO standardDAO;
    private InspectionDAO inspectionDAO;
    private TermDAO termDAO;
    private DocumentTemplateDAO documentTemplateDAO;

    public DataInputService() {
        this.standardDAO = new StandardDAO();
        this.inspectionDAO = new InspectionDAO();
        this.termDAO = new TermDAO();
        this.documentTemplateDAO = new DocumentTemplateDAO();
    }

    // ==================== 标准信息增删改查 ====================

    /**
     * 添加标准信息
     */
    public boolean addStandard(Standard standard) {
        return standardDAO.addStandard(standard);
    }

    /**
     * 修改标准信息
     */
    public boolean updateStandard(Standard standard) {
        return standardDAO.updateStandard(standard);
    }

    /**
     * 删除标准信息
     */
    public boolean deleteStandard(int standardId) {
        return standardDAO.deleteStandard(standardId);
    }

    /**
     * 根据ID查询标准信息
     */
    public Standard getStandardById(int standardId) {
        return standardDAO.getStandardById(standardId);
    }

    /**
     * 获取所有标准信息
     */
    public List<Standard> getAllStandards() {
        return standardDAO.getAllStandards();
    }

    /**
     * 根据标准编号查询标准信息
     */
    public Standard getStandardByCode(String standardCode) {
        return standardDAO.getStandardByCode(standardCode);
    }

    // ==================== 检验要求增删改查 ====================

    /**
     * 添加检验要求
     */
    public boolean addInspection(Inspection inspection) {
        return inspectionDAO.addInspection(inspection);
    }

    /**
     * 修改检验要求
     */
    public boolean updateInspection(Inspection inspection) {
        return inspectionDAO.updateInspection(inspection);
    }

    /**
     * 删除检验要求
     */
    public boolean deleteInspection(int inspectionId) {
        return inspectionDAO.deleteInspection(inspectionId);
    }

    /**
     * 根据标准ID获取检验要求列表
     */
    public List<Inspection> getInspectionsByStandardId(int standardId) {
        return inspectionDAO.getInspectionsByStandardId(standardId);
    }

    /**
     * 根据ID获取检验要求
     */
    public Inspection getInspectionById(int inspectionId) {
        return inspectionDAO.getInspectionById(inspectionId);
    }

    // ==================== 术语定义增删改查 ====================

    /**
     * 添加术语定义
     */
    public boolean addTerm(Term term) {
        return termDAO.addTerm(term);
    }

    /**
     * 修改术语定义
     */
    public boolean updateTerm(Term term) {
        return termDAO.updateTerm(term);
    }

    /**
     * 删除术语定义
     */
    public boolean deleteTerm(int termId) {
        return termDAO.deleteTerm(termId);
    }

    /**
     * 根据标准ID获取术语定义列表
     */
    public List<Term> getTermsByStandardId(int standardId) {
        return termDAO.getTermsByStandardId(standardId);
    }

    /**
     * 根据ID获取术语定义
     */
    public Term getTermById(int termId) {
        return termDAO.getTermById(termId);
    }

    // ==================== 文档模板增删改查 ====================

    /**
     * 创建新文档（带自动编号）
     */
    public boolean createDocument(DocumentTemplate document) {
        return documentTemplateDAO.createDocument(document);
    }

    /**
     * 更新文档
     */
    public boolean updateDocument(DocumentTemplate document) {
        return documentTemplateDAO.updateDocument(document);
    }

    /**
     * 删除文档
     */
    public boolean deleteDocument(int documentId) {
        return documentTemplateDAO.deleteDocument(documentId);
    }

    /**
     * 根据ID获取文档
     */
    public DocumentTemplate getDocumentById(int documentId) {
        return documentTemplateDAO.getDocumentById(documentId);
    }

    /**
     * 根据用户名获取文档列表
     */
    public List<DocumentTemplate> getDocumentsByUser(String username) {
        return documentTemplateDAO.getDocumentsByUser(username);
    }

    /**
     * 获取所有文档
     */
    public List<DocumentTemplate> getAllDocuments() {
        return documentTemplateDAO.getAllDocuments();
    }

    /**
     * 生成文档编号（用于测试或外部调用）
     */
    public String generateDocumentNumber() {
        // 这个方法可以暴露给外部调用，用于生成文档编号
        // 实际实现是在DocumentTemplateDAO中
        try {
            // 创建一个临时文档来获取编号
            DocumentTemplate tempDoc = new DocumentTemplate();
            documentTemplateDAO.createDocument(tempDoc);
            String number = tempDoc.getDocumentNumber();
            // 删除临时文档
            documentTemplateDAO.deleteDocument(tempDoc.getDocumentId());
            return number;
        } catch (Exception e) {
            return "DOC-" + System.currentTimeMillis();
        }
    }

    // ==================== 综合查询方法 ====================

    /**
     * 根据关键词搜索检验要求
     */
    public List<Inspection> searchInspectionsByKeyword(String keyword) {
        // 这里可以实现关键词搜索逻辑
        // 暂时返回空列表，实际实现需要根据需求完善
        return java.util.Collections.emptyList();
    }

    /**
     * 根据关键词搜索术语定义
     */
    public List<Term> searchTermsByKeyword(String keyword) {
        // 这里可以实现关键词搜索逻辑
        // 暂时返回空列表，实际实现需要根据需求完善
        return java.util.Collections.emptyList();
    }

    /**
     * 获取标准及其相关数据的完整信息
     */
    public Standard getStandardWithDetails(int standardId) {
        Standard standard = standardDAO.getStandardById(standardId);
        if (standard != null) {
            // 可以在这里加载相关的检验要求和术语定义
            // 根据需求决定是否立即加载所有关联数据
        }
        return standard;
    }

    /**
     * 验证数据是否存在
     */
    public boolean isStandardExists(String standardCode) {
        return standardDAO.getStandardByCode(standardCode) != null;
    }

    /**
     * 批量操作相关方法（可以根据需要扩展）
     */

    /**
     * 批量添加检验要求
     */
    public boolean batchAddInspections(List<Inspection> inspections) {
        boolean allSuccess = true;
        for (Inspection inspection : inspections) {
            if (!inspectionDAO.addInspection(inspection)) {
                allSuccess = false;
            }
        }
        return allSuccess;
    }

    /**
     * 批量添加术语定义
     */
    public boolean batchAddTerms(List<Term> terms) {
        boolean allSuccess = true;
        for (Term term : terms) {
            if (!termDAO.addTerm(term)) {
                allSuccess = false;
            }
        }
        return allSuccess;
    }

    // ==================== 统计方法 ====================

    /**
     * 获取标准数量统计
     */
    public int getStandardCount() {
        List<Standard> standards = standardDAO.getAllStandards();
        return standards.size();
    }

    /**
     * 获取检验要求数量统计
     */
    public int getInspectionCount() {
        int total = 0;
        List<Standard> standards = standardDAO.getAllStandards();
        for (Standard standard : standards) {
            List<Inspection> inspections = inspectionDAO.getInspectionsByStandardId(standard.getId());
            total += inspections.size();
        }
        return total;
    }

    /**
     * 获取术语定义数量统计
     */
    public int getTermCount() {
        int total = 0;
        List<Standard> standards = standardDAO.getAllStandards();
        for (Standard standard : standards) {
            List<Term> terms = termDAO.getTermsByStandardId(standard.getId());
            total += terms.size();
        }
        return total;
    }

    /**
     * 获取文档数量统计
     */
    public int getDocumentCount() {
        List<DocumentTemplate> documents = documentTemplateDAO.getAllDocuments();
        return documents.size();
    }

    /**
     * 获取用户创建的文档数量
     */
    public int getUserDocumentCount(String username) {
        List<DocumentTemplate> documents = documentTemplateDAO.getDocumentsByUser(username);
        return documents.size();
    }

    // ==================== 数据验证方法 ====================

    /**
     * 验证标准数据是否完整
     */
    public boolean validateStandardData(Standard standard) {
        if (standard == null) return false;
        if (standard.getStandardCode() == null || standard.getStandardCode().trim().isEmpty()) return false;
        if (standard.getStandardName() == null || standard.getStandardName().trim().isEmpty()) return false;
        if (standard.getEnglishName() == null || standard.getEnglishName().trim().isEmpty()) return false;
        if (standard.getPublishDate() == null) return false;
        if (standard.getImplementationDate() == null) return false;
        return true;
    }

    /**
     * 验证检验要求数据是否完整
     */
    public boolean validateInspectionData(Inspection inspection) {
        if (inspection == null) return false;
        if (inspection.getStandardId() == null || inspection.getStandardId() <= 0) return false;
        if (inspection.getProjectNum() == null || inspection.getProjectNum().trim().isEmpty()) return false;
        if (inspection.getProjectName() == null || inspection.getProjectName().trim().isEmpty()) return false;
        return true;
    }

    /**
     * 验证术语定义数据是否完整
     */
    public boolean validateTermData(Term term) {
        if (term == null) return false;
        if (term.getStandardId() == null || term.getStandardId() <= 0) return false;
        if (term.getProjectNum() == null || term.getProjectNum().trim().isEmpty()) return false;
        if (term.getTermName() == null || term.getTermName().trim().isEmpty()) return false;
        if (term.getDefinition() == null || term.getDefinition().trim().isEmpty()) return false;
        return true;
    }

    /**
     * 验证文档数据是否完整
     */
    public boolean validateDocumentData(DocumentTemplate document) {
        if (document == null) return false;
        if (document.getProductName() == null || document.getProductName().trim().isEmpty()) return false;
        if (document.getCreatedBy() == null || document.getCreatedBy().trim().isEmpty()) return false;
        return true;
    }

    // ==================== 工具方法 ====================

    /**
     * 初始化测试数据
     */
    public void initializeTestData() {
        // 可以在这里添加一些测试数据初始化的逻辑
        System.out.println("数据服务初始化完成");
    }

    /**
     * 清理资源（如果需要的话）
     */
    public void cleanup() {
        // 可以在这里添加资源清理逻辑
        System.out.println("数据服务清理完成");
    }

    /**
     * 检查数据库连接状态
     */
    public boolean checkDatabaseConnection() {
        try {
            List<Standard> standards = standardDAO.getAllStandards();
            return true;
        } catch (Exception e) {
            System.err.println("数据库连接检查失败: " + e.getMessage());
            return false;
        }
    }
}